import 'package:flutter/widgets.dart';

/// Elegance控件库的核心基础类
/// 
/// 这个文件定义了控件库的基础类和混入，利用Dart的语言特性
/// 实现属性观察、生命周期管理等核心功能。

/// 可观察对象的混入
/// 
/// 使用Dart的mixin特性，为类提供属性变化通知能力
mixin ObservableMixin {
  final List<VoidCallback> _listeners = [];
  bool _disposed = false;

  /// 添加属性变化监听器
  void addListener(VoidCallback listener) {
    if (_disposed) return;
    _listeners.add(listener);
  }

  /// 移除属性变化监听器
  void removeListener(VoidCallback listener) {
    _listeners.remove(listener);
  }

  /// 通知所有监听器属性已变化
  @protected
  void notifyListeners() {
    if (_disposed) return;
    // 创建副本以防在回调中修改列表
    final listeners = List<VoidCallback>.from(_listeners);
    for (final listener in listeners) {
      listener();
    }
  }

  /// 释放资源
  @mustCallSuper
  void dispose() {
    _disposed = true;
    _listeners.clear();
  }

  /// 是否已释放
  bool get disposed => _disposed;
}

/// 带属性键的可观察对象
class ObservableProperty<T> with ObservableMixin {
  /// 创建一个带初始值的可观察属性
  ObservableProperty(this._value);

  T _value;

  /// 获取属性值
  T get value => _value;

  /// 设置属性值，值变化时通知监听器
  set value(T newValue) {
    if (_value == newValue) return;
    _value = newValue;
    notifyListeners();
  }

  @override
  String toString() => 'ObservableProperty(value: $value)';
}

/// Elegance控件的基础抽象类
/// 
/// 所有Elegance控件都应继承自此类，提供统一的生命周期和属性管理
abstract class EleganceBaseWidget extends StatelessWidget {
  /// 创建控件时传入的键
  const EleganceBaseWidget({super.key, this.tag});

  /// 用于标识控件的标签，可用于测试和调试
  final Object? tag;

  /// 构建控件的子部件
  Widget buildContent(BuildContext context);

  @override
  Widget build(BuildContext context) {
    // 可以在这里添加通用的包装逻辑
    return buildContent(context);
  }
}

/// 带状态的Elegance控件基础类
abstract class EleganceStatefulWidget extends StatefulWidget {
  /// 创建带状态的控件
  const EleganceStatefulWidget({super.key, this.tag});

  /// 用于标识控件的标签
  final Object? tag;
}

/// Elegance控件的状态基础类
abstract class EleganceState<T extends EleganceStatefulWidget> extends State<T> {
  @override
  void initState() {
    super.initState();
    initEleganceState();
  }

  /// Elegance特定的初始化逻辑
  @protected
  void initEleganceState() {}

  @override
  void didUpdateWidget(covariant T oldWidget) {
    super.didUpdateWidget(oldWidget);
    updateEleganceWidget(oldWidget);
  }

  /// 当widget更新时调用
  @protected
  void updateEleganceWidget(T oldWidget) {}

  @override
  void dispose() {
    disposeEleganceResources();
    super.dispose();
  }

  /// 释放Elegance相关资源
  @protected
  void disposeEleganceResources() {}
}

/// 样式属性混入
mixin StyleableMixin<T extends StyleableMixin<T>> {
  Map<String, dynamic>? _styleProperties;

  /// 获取所有样式属性
  Map<String, dynamic> get styleProperties => _styleProperties ??= {};

  /// 设置样式属性
  @protected
  T setStyle(String property, dynamic value) {
    styleProperties[property] = value;
    return this as T;
  }

  /// 获取样式属性
  @protected
  dynamic getStyle(String property, {dynamic defaultValue}) {
    return styleProperties[property] ?? defaultValue;
  }
}